/**
 * 修复数据库中带引号的 userId
 * 这个脚本会：
 * 1. 查找所有带引号的 userId
 * 2. 清理这些 userId（去除前后引号和空格）
 * 3. 如果清理后的 userId 已存在，合并数据或更新记录
 * 4. 更新相关的收藏记录（如果有）
 */

import { getDB } from '../shared/db/index.js'
import { fileURLToPath } from 'url'
import { dirname, join } from 'path'

const __filename = fileURLToPath(import.meta.url)
const __dirname = dirname(__filename)

/**
 * 清理 userId，去除前后引号和空格
 */
function cleanUserId(userId) {
  if (!userId || typeof userId !== 'string') {
    return userId
  }
  return userId.trim().replace(/^["']+|["']+$/g, '')
}

/**
 * 检查 userId 是否带引号
 */
function hasQuotes(userId) {
  if (!userId || typeof userId !== 'string') {
    return false
  }
  const trimmed = userId.trim()
  return trimmed.startsWith('"') || trimmed.startsWith("'") || 
         trimmed.endsWith('"') || trimmed.endsWith("'")
}

/**
 * 修复用户表中的 userId
 */
function fixUserTable() {
  const db = getDB()
  
  console.log('开始修复 User 表中的 userId...')
  
  // 查找所有带引号的 userId
  const allUsersStmt = db.prepare('SELECT id, userId, type FROM User')
  const allUsers = allUsersStmt.all()
  
  let fixedCount = 0
  let mergedCount = 0
  let errorCount = 0
  
  for (const user of allUsers) {
    if (!hasQuotes(user.userId)) {
      continue // 跳过不带引号的
    }
    
    const oldUserId = user.userId
    const cleanId = cleanUserId(oldUserId)
    
    if (!cleanId || cleanId === oldUserId) {
      console.log(`跳过无效 userId: ${oldUserId}`)
      continue
    }
    
    console.log(`发现带引号的 userId: "${oldUserId}" -> "${cleanId}"`)
    
    try {
      // 检查清理后的 userId 是否已存在
      const existingUserStmt = db.prepare('SELECT id FROM User WHERE userId = ?')
      const existingUser = existingUserStmt.get(cleanId)
      
      if (existingUser) {
        // 如果已存在，需要合并数据
        console.log(`  -> 清理后的 userId "${cleanId}" 已存在，需要合并数据`)
        
        // 更新收藏表中的 userId（如果有）
        try {
          const updateFavoriteStmt = db.prepare('UPDATE Favorite SET userId = ? WHERE userId = ?')
          const favoriteResult = updateFavoriteStmt.run(cleanId, oldUserId)
          if (favoriteResult.changes > 0) {
            console.log(`  -> 已更新 ${favoriteResult.changes} 条收藏记录`)
          }
        } catch (err) {
          console.log(`  -> 更新收藏记录时出错: ${err.message}`)
        }
        
        // 删除旧记录
        const deleteStmt = db.prepare('DELETE FROM User WHERE id = ?')
        deleteStmt.run(user.id)
        mergedCount++
        console.log(`  -> 已删除旧记录 (id: ${user.id})`)
      } else {
        // 如果不存在，直接更新 userId
        const updateStmt = db.prepare('UPDATE User SET userId = ? WHERE id = ?')
        updateStmt.run(cleanId, user.id)
        
        // 更新收藏表中的 userId（如果有）
        try {
          const updateFavoriteStmt = db.prepare('UPDATE Favorite SET userId = ? WHERE userId = ?')
          updateFavoriteStmt.run(cleanId, oldUserId)
        } catch (err) {
          // 收藏表可能不存在，忽略错误
        }
        
        fixedCount++
        console.log(`  -> 已更新 userId (id: ${user.id})`)
      }
    } catch (err) {
      errorCount++
      console.error(`  -> 处理失败: ${err.message}`)
    }
  }
  
  console.log(`\n修复完成:`)
  console.log(`  - 修复: ${fixedCount} 条记录`)
  console.log(`  - 合并: ${mergedCount} 条记录`)
  console.log(`  - 错误: ${errorCount} 条记录`)
}

/**
 * 修复收藏表中的 userId（如果有）
 */
function fixFavoriteTable() {
  const db = getDB()
  
  try {
    // 检查收藏表是否存在
    const checkTableStmt = db.prepare(`
      SELECT name FROM sqlite_master 
      WHERE type='table' AND name='Favorite'
    `)
    const tableExists = checkTableStmt.get()
    
    if (!tableExists) {
      console.log('收藏表不存在，跳过修复')
      return
    }
    
    console.log('\n开始修复 Favorite 表中的 userId...')
    
    // 查找所有带引号的 userId
    const allFavoritesStmt = db.prepare('SELECT DISTINCT userId FROM Favorite WHERE userId IS NOT NULL')
    const allFavorites = allFavoritesStmt.all()
    
    let fixedCount = 0
    
    for (const favorite of allFavorites) {
      if (!hasQuotes(favorite.userId)) {
        continue
      }
      
      const oldUserId = favorite.userId
      const cleanId = cleanUserId(oldUserId)
      
      if (!cleanId || cleanId === oldUserId) {
        continue
      }
      
      try {
        const updateStmt = db.prepare('UPDATE Favorite SET userId = ? WHERE userId = ?')
        const result = updateStmt.run(cleanId, oldUserId)
        if (result.changes > 0) {
          fixedCount += result.changes
          console.log(`  修复收藏记录: "${oldUserId}" -> "${cleanId}" (${result.changes} 条)`)
        }
      } catch (err) {
        console.error(`  修复收藏记录失败: ${err.message}`)
      }
    }
    
    console.log(`修复完成: ${fixedCount} 条收藏记录`)
  } catch (err) {
    console.log(`修复收藏表时出错: ${err.message}`)
  }
}

/**
 * 主函数
 */
function main() {
  try {
    console.log('='.repeat(60))
    console.log('开始修复数据库中带引号的 userId')
    console.log('='.repeat(60))
    
    // 修复用户表
    fixUserTable()
    
    // 修复收藏表
    fixFavoriteTable()
    
    console.log('\n' + '='.repeat(60))
    console.log('修复完成！')
    console.log('='.repeat(60))
  } catch (error) {
    console.error('修复过程中出现错误:', error)
    process.exit(1)
  }
}

// 运行修复脚本
main()

